QuickTime 4 Reference

Adding Gradients

You specify gradient fills and their attributes by including these atoms in a vector data stream:

You specify the type of gradient (either linear or circular) with a kCurveGradientTypeAtom atom.
For linear gradients, you can specify the direction in which the gradient is drawn with a kCurveGradientAngleAtom atom. You specify this direction with an angle: for example, 0.0 specifies a top-to-bottom gradient, 90.0 specifies a right-to-left gradient, 180.0 specifies a bottom-to-top gradient, and 270.0 specifies a left-to-right gradient.
For circular gradients, you can specify the radius of the gradient with a kCurveGradientRadiusAtom atom.
You specify the colors for gradients with a kCurveGradientRecordAtom atom. A gradient must have at least two colors, for the beginning and end, but it can also any number of intermediate colors. Each color is specified by a GradientColorRecord structure. You can also add a kCurveGradientRecordAtom atom without data to disable gradient fills.
You can specify an offset for gradients with a kCurveGradientOffsetAtom atom. For circular gradients, this specifies the top left offset from the path being drawn. For linear gradients, it is the offset from the center of the rotated gradient line.

For more information about gradients, see "Gradients for Path Fills" .

Listing 6 shows how to create a rectangle with a left-to-right linear gradient fill.

Listing 6 Adding a left-to-right linear gradient fill to a rectangle



 
ComponentInstance vectorCodec;

Handle streamH;

Handle pathH;

gxPoint points[4];

Boolean isOnCurve[4];

GradientColorRecord gradientColors[2];

ARGBColor white, black;

int i;

long value;



/* specify the gradient colors and where they start and end */

white.alpha = 255;

white.red = 255;

white.green = 255;

white.blue = 255;

black.alpha = 255;

black.red = 0;

black.green = 0;

black.blue = 0;

gradientColors[1].thisColor = white;

gradientColors[1].endingPercentage = ff(0);

gradientColors[2].thisColor = black;

gradientColors[2].endingPercentage = ff(1);



/* open the vector codec component */

OpenADefaultComponent (decompressorComponentType,

                        kVectorCodecType, &vectorCodec);



/* create a new vector data stream */

CurveCreateVectorStream (vectorCodec, streamH);

value=kLinearGradient;



/* add an atom to the vector data stream that specifies to 

   use linear gradient fills for subsequent paths */

CurveAddAtomToVectorStream (ci, kCurveGradientTypeAtom, sizeof(long),

                            &value, streamH);



/* add an atom to the vector data stream that specifies to 

   draw linear gradient fills from left to right for subsequent paths */

CurveAddAtomToVectorStream (ci, kCurveGradientAngleAtom, sizeof(Fixed),

                            ff(270), streamH);



/* add an atom to the vector data stream that specifies

   gradient colors */

CurveAddAtomToVectorStream (ci, kCurveGradientRecordAtom,

                            sizeof(GradientColorRecord)*2,

                            gradientColors, streamH);



/* specify the points for the path and whether each one is 

   on the path */

points[0].x = ff(150);

points[0].y = ff(150);

isOnCurve[0] = TRUE;

points[1].x = ff(300);

points[1].y = ff(150);

isOnCurve[1] = TRUE;

points[2].x = ff(300);

points[2].y = ff(100);

isOnCurve[2] = TRUE;

points[3].x = ff(100);

points[3].y = ff(100);

isOnCurve[3] = TRUE;



/* create the path and add the points to it */

CurveNewPath (vectorCodec, &pathH);

for (i = 0; i <= 3; i++)

    CurveInsertPointIntoPath (vectorCodec, &points[i], pathH,

                              1, i, isOnCurve[i]);



/* add the path to the vector data stream */

CurveAddPathAtomToVectorStream (vectorCodec, pathH, streamH);



/* mark the end of the vector data stream by adding a 

   kCurveEndAtom atom to the stream */

CurveAddZeroAtomToVectorStream (vectorCodec, streamH);



/* use the vector codec here to decompress and display the vector data */



/* dispose of stream and path handles when done */

DisposeHandle (streamH);

DisposeHandle (pathH);

Figure 67 shows what is drawn for this vector data stream.

Figure 67 A rectangle with a linear left-to-right gradient fill